/*
* 角色管理模块
*/
const express = require('express');
const router = express.Router();
// 引入数据库
const db = require("../../config/db");
// 引入时间包
const moment = require("moment");
// 引入方法库
const { toCamelCase, toUnderlineCase, verifyToken} = require("../../config/utils");
// 引入日志
const log = require("../log");
//m密码使用md5模块进行的加密
const md5 = require('md5');

// 获取所有角色列表
router.get("/list", async (req, res) => {
    console.log("===========获取角色列表接口============");
    // 获取参数
    let { pageNum, pageSize, roleKey, roleName, status, params } = req.query;
    // 拼接sql语句
    let sql = "select * from sys_role";
    let sql_where = ` where 1=1`;
    if(roleKey){
        sql_where += ` and role_key like '%${roleKey}%'`;
    }
    if(roleName){
        sql_where += ` and role_name like '%${roleName}%'`;
    }
    if(status){
        sql_where += ` and status = '${status}'`;
    }
    if(params){
        sql_where += ` and create_time between '${params['beginTime']}' and  '${params['endTime']}'`;
    }
    if(roleKey || roleName || status || params){
        sql += sql_where;
    }
    
    // 分页
    sql += ` limit ${(pageNum-1)*pageSize}, ${pageSize}`;
    // 查询数据库
    db.query("查询角色列表", sql, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "查询角色列表失败", data: err});
            return;
        }
        // 查询总数
        db.query("查询角色总数", `select count(*) as count from sys_role ${sql_where}`, (err, count)=>{
            if(err){
                res.send({code: 500, msg: "查询角色总数失败", data: err});
                return;
            }
            if(result.length > 0){
                 // 变量Json数组key转成下划线第一个大写
                 result = result.map(item => {
                    return toCamelCase(item)
                })
                res.send({code: 200, msg: "查询角色列表成功", rows: result, total: count[0].count});
            }else{
                res.send({code: 200, msg: "查询角色列表成功", rows: [], total: 0});
            }
        })
    })
})

// 查询单个角色
router.get(/^\/(\d+)$/, (req, res) => {
    console.log("===========查询单个角色接口，正则匹配============");
    // 获取参数
    let url_arr = req.url.split("/");
    const id = url_arr[url_arr.length - 1];
   
    db.query("查询单个角色", `select * from sys_role where role_id = ${id}`, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "查询单个角色失败", data: err});
            return;
        }
        if(result.length > 0){
            // 变量Json数组key转成下划线第一个大写
            result = result.map(item => {
                return toCamelCase(item)
            })
            res.send({code: 200, msg: "查询单个角色成功", data: result[0]});
        }else{
            res.send({code: 500, msg: "查询单个角色失败"});
        }
    })
})

// 新增角色
router.post("/", (req, res)=>{
    console.log("===========新增角色接口============");
    // 获取参数
    let {roleName, roleKey, status, roleSort, menuCheckStrictly, menuIds, remark} = req.body;
    // 获取创建人
    let {username} = verifyToken(req.headers.authorization);
    // 获取创建时间
    let createTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 判断权限字符和角色名称是否重复
    db.query("查询权限字符和角色名称是否重复", `select * from sys_role where role_name = '${roleName}' or role_key = '${roleKey}'`, (err, sql_check_result)=>{
        if(err){
            res.send({code: 500, msg: "查询权限字符和角色名称是否重复失败", data: err});
            return;
        }
        if(sql_check_result.length > 0){
            res.send({code: 500, msg: "权限字符或角色名称已存在"});
            return;
        }
        // 插入数据库
        let sql = `insert into sys_role (role_name, role_key, status, role_sort, menu_check_strictly, remark, create_by, create_time)
        values 
        ('${roleName}', '${roleKey}',  '${status}',  '${roleSort}', ${menuCheckStrictly ? "1" : '0'}, ${remark ? "'"+remark+"'" : null}, 
        '${username}', '${createTime}')`;
        db.query("新增角色", sql, (err, result)=>{
            if(err){
                res.send({code: 500, msg: "新增角色失败", data: err});
                return;
            }
            if(result.affectedRows > 0){
                res.send({code: 200, msg: "新增角色成功"});
                // 新增角色成功后，新增角色和菜单关联表
                // 获取新增角色id
                let roleId = result.insertId;
                // 获取菜单id,组合成数组
                
                let menuIdArr = menuIds.map(item => {
                    return [roleId,item]
                });
                // 插入数据
                let sql = `insert into sys_role_menu (role_id, menu_id) values ?`;
                db.query("新增角色和菜单关联表", sql, menuIdArr, (err, result)=>{
                    if(err){
                        console.log("新增角色和菜单关联表失败");
                        return;
                    }
                    if(result.affectedRows > 0){
                        console.log("新增角色和菜单关联表成功");
                    }else{
                        console.log("新增角色和菜单关联表成功");
                    }
                })
            }else{
                res.send({code: 500, msg: "新增角色失败"});
            }
        })
    })
})

// 修改角色  暂时不修改权限表sys_role_menu
router.put("/", (req, res)=>{
    console.log("===========修改角色接口============");
    // 获取参数
    let {roleName, roleKey, status, roleSort, menuIds, remark, roleId} = req.body;
    // 获取修改人
    let {username} = verifyToken(req.headers.authorization);
    // 获取修改时间
    let updateTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 判断权限字符和角色名称是否重复
    db.query("查询权限字符和角色名称是否重复", `select * from sys_role where role_id != ${roleId} and (role_name = '${roleName}' or role_key = '${roleKey}')`, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "查询权限字符和角色名称是否重复失败", data: err});
            return;
        }
        if(result.length > 0){
            res.send({code: 500, msg: "权限字符或角色名称已存在", data: []});
            return;
        }
        // 修改角色sql
        let sql = `update sys_role set role_name = '${roleName}', role_key = '${roleKey}', status = '${status}', role_sort = '${roleSort}',
        remark = ${remark ? "'"+remark+"'" : null}, update_by = '${username}', update_time = '${updateTime}'
        where role_id = '${roleId}'`;
        db.query("修改角色", sql, (err, result)=>{
            if(err){
                res.send({code: 500, msg: "修改角色失败", data: err});
                return;
            }
            if(result.affectedRows > 0){
                res.send({code: 200, msg: "修改角色成功", data: []});
            }else{
                res.send({code: 500, msg: "修改角色失败", data: []});
            }
        })
    })
})

// 修改角色状态
router.put("/changeStatus", (req, res)=>{
    console.log("===========修改角色状态接口============");
    // 获取参数
    let {roleId, status} = req.body;
    // 获取修改人
    let {username} = verifyToken(req.headers.authorization);
    // 获取修改时间
    let updateTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 修改角色状态sql
    let sql = `update sys_role set status = '${status}', update_by = '${username}', update_time = '${updateTime}' where role_id = '${roleId}'`;
    db.query("修改角色状态", sql, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "修改角色状态失败", data: err});
            return;
        }
        if(result.affectedRows > 0){
            res.send({code: 200, msg: "修改角色状态成功", data: []});
        }else{
            res.send({code: 500, msg: "修改角色状态失败", data: []});
        }
    })
})

// 修改角色权限范围
router.put("/dataScope", (req, res)=>{
    console.log("===========修改角色权限范围接口============");
    // 获取参数
    let {roleId, dataScope} = req.body;
    // 获取修改人
    let {username} = verifyToken(req.headers.authorization);
    // 获取修改时间
    let updateTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 修改角色权限范围sql
    let sql = `update sys_role set data_scope = '${dataScope}', update_by = '${username}', update_time = '${updateTime}' where role_id = '${roleId}'`;
    db.query("修改角色权限范围", sql, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "修改角色权限范围失败", data: err});
            return;
        }
        if(result.affectedRows > 0){
            res.send({code: 200, msg: "修改角色权限范围成功", data: []});
        }
    })
})

// 查询角色已授权用户列表
router.get("/authUser/allocatedList", (req, res)=>{
    console.log("===========查询角色已授权用户列表接口============");
    // 获取参数
    let {roleId, userName, phonenumber, pageNum, pageSize} = req.query;
    // 根据角色id查询用户id，再根据用户id查询用户信息
    let sql_union = `select * from sys_user 
    where user_id in (select user_id from sys_user_role where role_id = '${roleId}')`;
    let sql_where = ''
    // 判断是否需要添加查询条件
    if(userName){
        sql_where += ` and user_name like '%${userName}%'`;
    }
    if(phonenumber){
        sql_where += ` and phonenumber like '%${phonenumber}%'`;
    }
    if(pageNum || pageSize){
        sql_union += sql_where
    }
    // 添加分页条件
    sql_union += ` limit ${(pageNum-1)*pageSize}, ${pageSize}`;
    // 查询数据库
    db.query("查询角色已授权用户列表", sql_union, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "查询角色已授权用户列表失败", data: err});
            return;
        }
        if(result.length > 0){
            // 查询总数
            let sql_count = `select count(*) as total from sys_user 
            where user_id in (select user_id from sys_user_role where role_id = '${roleId}')`;
            sql_count += sql_where
            db.query("查询角色已授权用户总数", sql_count, (err, count)=>{
                if(err){
                    res.send({code: 500, msg: "查询角色已授权用户总数失败", data: err});
                    return;
                }
                // 变量Json数组key转成下划线第一个大写
                result = result.map(item => {
                    return toCamelCase(item)
                })
                res.send({code: 200, msg: "查询角色已授权用户列表成功", total: count[0].total, rows: result});
            })
        }else{
            res.send({code: 200, msg: "查询角色已授权用户列表成功", total: 0, rows: []});
        }
    })
    
})

// 查询角色未授权用户列表 (默认规则，一个用户只能有一个角色)
router.get("/authUser/unallocatedList", (req, res)=>{
    console.log("===========查询角色未授权用户列表接口============");
    // 获取参数
    let {roleId, userName, phonenumber, pageNum, pageSize} = req.query;
    // 查询用户权限表，排除已授权用户
    let sql_un_user = `select * from sys_user 
    where user_id not in (select user_id from sys_user_role)`;
    let sql_where = ''
    // 判断是否需要添加查询条件
    if(userName){
        sql_where += ` and user_name like '%${userName}%'`;
    }
    if(phonenumber){
        sql_where += ` and phonenumber like '%${phonenumber}%'`;
    }
    if(pageNum || pageSize){
        sql_un_user += sql_where
    }
    // 添加分页条件
    sql_un_user += ` limit ${(pageNum-1)*pageSize}, ${pageSize}`;
    // 查询数据库
    db.query("查询角色未授权用户列表", sql_un_user, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "查询角色未授权用户列表失败", data: err});
            return;
        }
        if(result.length > 0){
            // 查询总数
            let sql_count = `select count(*) as total from sys_user 
            where user_id not in (select user_id from sys_user_role)`;
            sql_count += sql_where
            db.query("查询角色未授权用户总数", sql_count, (err, count)=>{
                if(err){
                    res.send({code: 500, msg: "查询角色未授权用户总数失败", data: err});
                    return;
                }
                // 变量Json数组key转成下划线第一个大写
                result = result.map(item => {
                    return toCamelCase(item)
                })
                res.send({code: 200, msg: "查询角色未授权用户列表成功", total: count[0].total, rows: result});
            })
        }else{
            res.send({code: 200, msg: "查询角色未授权用户列表成功", total: 0, rows: []});
        }
    })
    
})

// 删除角色
router.delete("/:id", (req, res) => {
    console.log("===========删除角色接口============");
    // 获取参数
    let {id} = req.params;
     // 拼接sql,删除多条数据
     let sql = `delete from sys_role where role_id in(${id})`;
    // 查询数据库
    db.query("删除角色", sql, (err, result) => {
        if (err) {
            res.send({code: 500, msg: "删除角色失败", data: err});
            return
        }
        if(result.affectedRows > 0){
            res.send({code: 200, msg: "删除角色成功"})
            // 删除角色用户关联表
            let sql2 = `delete from sys_user_role where role_id in(${id})`;
            db.query("删除角色用户关联表", sql2, (err, result)=>{
                if(err){
                    console.log("删除角色用户关联表失败", err)
                    return
                }
                if(result.affectedRows > 0){
                    console.log("删除角色用户关联表成功")
                }
            })
            // 删除角色菜单关联表
            let sql3 = `delete from sys_role_menu where role_id in(${id})`;
            db.query("删除角色菜单关联表", sql3, (err, result)=>{
                if(err){
                    console.log("删除角色菜单关联表失败", err)
                    return
                }
                if(result.affectedRows > 0){
                    console.log("删除角色菜单关联表成功")
                }
            })
        }else{
            res.send({code: 500, msg: "删除角色失败"})
        }
    })
})

// 取消授权用户
router.put("/authUser/cancel", (req, res) => {
    console.log("===========取消授权用户接口============");
    // 获取参数
    let {roleId, userId} = req.body;
    // 拼接sql,删除多条数据
    let sql = `delete from sys_user_role where role_id = '${roleId}' and user_id in(${userId})`;
    // 查询数据库
    db.query("取消授权用户", sql, (err, result) => {
        if (err) {
            send({code: 500, msg: "取消授权用户失败", data: err});
            return
        }
        if(result.affectedRows > 0){
            res.send({code: 200, msg: "取消授权用户成功"})
        }else{
            res.send({code: 500, msg: "取消授权用户失败"})
        }
    })
})

// 授权用户选择
router.put("/authUser/selectAll", (req, res) => {
    console.log("===========授权用户选择接口============");
    // 获取参数
    let {roleId, userIds} = req.query;
    // 生成数组
    let arr_user = userIds.split(",");
    
    let arr_sql = arr_user.map(item => {
        return [roleId, item]
    })
    // 插入多条数据
    let sql = `insert into sys_user_role (role_id, user_id) values ?`;
    db.query("授权用户选择", sql, arr_sql, (err, result) => {
        if(err){
            send({code: 500, msg: "授权用户选择失败", data: err});
            return
        }
        if(result.affectedRows > 0){
            res.send({code: 200, msg: "授权用户选择成功"})
        }else{
            res.send({code: 500, msg: "授权用户选择失败"})
        }
    })

})



module.exports = router;
